package service

import (
	"encoding/json"
	"qld2devservice/models"
	"qld2devservice/utils"
	"strconv"
	"time"
)

// StartOutLetUseDeviceBody 打开设备传入参数
type StateRecvBody struct {
	State string  `json:"state"`
	Temp  float64 `json:"temp"`
}

func AnalyzeStateMessage(snNum, message string) {
	var mapResult StateRecvBody
	err := json.Unmarshal([]byte(message), &mapResult)
	if err != nil {
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
		if len(message) > 9 && message[9] != '"' {
			message = message[:9] + "\"" + message[9:]
			utils.MyPrint(utils.PRINT_WARN, message)
			err = json.Unmarshal([]byte(message), &mapResult)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, err.Error())
			}
		}
	}
	if mapResult.State != "" {
		if stateOld, err := RedisGet(snNum+"/state", "0000000"); err != nil {
			utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "MakeOperateDeviceCmd:1,etcd设备state获取失败"))
		} else {
			checkState(mapResult.State, stateOld, snNum)
		}
		if err = RedisSave(snNum+"/state", mapResult.State); err != nil {
			utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "MakeOperateDeviceCmd:2,etcd设备temp保存失败"))
		}
		if err = MqttNoticeSend(snNum+"/state", mapResult.State); err != nil {
			utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
		}
	}
	if mapResult.Temp != 0 {
		if err = RedisSave(snNum+"/temp", strconv.FormatFloat(mapResult.Temp, 'E', -1, 64)); err != nil {
			utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "MakeOperateDeviceCmd:2,etcd设备temp保存失败"))
		}
		if err = MqttNoticeSend(snNum+"/temp", strconv.FormatFloat(mapResult.Temp, 'E', -1, 64)); err != nil {
			utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
		}
	}
}

func checkState(state, stateOld, snNum string) {
	if isWorking, err := RedisGet(snNum+"/isWorking", "0"); err != nil {
		utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:1，etcd数据isWorking获取失败"))
	} else {
		if stateOld[0] != state[0] {
			if (stateOld[0] == '0' || stateOld[0] == '1' || stateOld[0] == '2' || stateOld[0] == '3') && (state[0] == '4' || state[0] == '5' || state[0] == '6') {
				if err := RedisSave(snNum+"/connectInfo", "1"); err != nil { // 已连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:1,数据库etcd设备已连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "1"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '4' && (state[0] == '1' || state[0] == '2' || state[0] == '3') {
				if err := RedisSave(snNum+"/connectInfo", "0"); err != nil { // 未连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:2,数据库etcd设备未连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "0"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '4' && (state[0] == '5' || state[0] == '6') {
				if err := RedisSave(snNum+"/connectInfo", "1"); err != nil { // 已连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备已连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "1"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '4' && state[0] == '7' {
				time.AfterFunc(time.Second*60, func() {
					if stateNewest, err := RedisGet(snNum+"/state", "0000000"); err != nil {
						if stateNewest[0] == '4' || stateNewest[0] == '7' {
							// 未允许充电，结束订单
							stateFinishOrder(snNum, 4, "汽车未允许充电") //1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
						}
					}
				})
			}
			if stateOld[0] == '5' && state[0] == '4' {
				if err := RedisSave(snNum+"/connectInfo", "1"); err != nil { // 已连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备已连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "1"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '5' && state[0] == '8' {
				if err := RedisSave(snNum+"/connectInfo", "2"); err != nil { // 正在充电
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备正在充电信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "2"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '6' && state[0] == '9' {
				if err := RedisSave(snNum+"/connectInfo", "2"); err != nil { // 正在充电
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备正在充电信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "2"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '7' && state[0] == '4' {
				if err := RedisSave(snNum+"/connectInfo", "1"); err != nil { // 已连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备已连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "1"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '7' && state[0] == '8' {
				if err := RedisSave(snNum+"/connectInfo", "2"); err != nil { // 正在充电
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备正在充电信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "2"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if stateOld[0] == '8' && state[0] == '7' {
				// 充电停止，结束订单，认为是充满吧
				time.AfterFunc(2*time.Second, func() {
					stateFinishOrder(snNum, 1, "") //1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
				})
			}
			if stateOld[0] == '5' && (state[0] == '1' || state[0] == '2' || state[0] == '3') {
				if err := RedisSave(snNum+"/connectInfo", "0"); err != nil { // 未连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:2,数据库etcd设备未连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "0"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if (stateOld[0] == '1' || stateOld[0] == '2' || stateOld[0] == '3') && state[0] == '5' {
				if err := RedisSave(snNum+"/connectInfo", "1"); err != nil { // 已连接
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备已连接信息推送失败"))
				}
				if err = MqttNoticeSend(snNum+"/connectInfo", "1"); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
				}
			}
			if (state[0] == '1' || state[0] == '2' || state[0] == '3' || state[0] == '4' || state[0] == '5' || state[0] == '6') && stateOld[0] != '7' && stateOld[0] != '8' && stateOld[0] != '9' && isWorking == "1" {
				time.AfterFunc(5*time.Second, func() {
					if stateLast, err := RedisGet(snNum+"/state", "0000000"); err != nil {
						utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "MakeOperateDeviceCmd:1,etcd设备state获取失败"))
					} else if stateLast[0] != '7' && stateLast[0] != '8' && stateLast[0] != '9' {
						if qldOutlets, err := models.GetQldOutletsBySnNum(snNum); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, err.Error())
						} else if len(qldOutlets) == 0 {
							utils.MyPrint(utils.PRINT_WARN, "checkState:获取设备失败，snNum=", snNum)
						} else {
							if qldOutlets[0].IsWorking == 1 { //这里数据库和内存中状态不一致，可能是外部修改导致，认为被拔出
								stateFinishOrder(snNum, 5, "") //1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
							}
						}
						// 强制重新插拔
						if err := RedisSave(snNum+"/connectInfo", "0"); err != nil { // 未连接
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:2,数据库etcd设备未连接信息推送失败"))
						}
						if err = MqttNoticeSend(snNum+"/connectInfo", "0"); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
						}
					}
				})
			}

		} else {
			if (state[0] == '1' || state[0] == '2' || state[0] == '3' || state[0] == '4' || state[0] == '5' || state[0] == '6') && isWorking == "1" {
				time.AfterFunc(60*time.Second, func() {
					if stateLast, err := RedisGet(snNum+"/state", "0000000"); err != nil {
						utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "MakeOperateDeviceCmd:1,etcd设备state获取失败"))
					} else if stateLast[0] != '7' && stateLast[0] != '8' && stateLast[0] != '9' {
						if qldOutlets, err := models.GetQldOutletsBySnNum(snNum); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, err.Error())
						} else if len(qldOutlets) == 0 {
							utils.MyPrint(utils.PRINT_WARN, "checkState:获取设备失败，snNum=", snNum)
						} else {
							if qldOutlets[0].IsWorking == 1 { //这里数据库和内存中状态不一致，可能是外部修改导致，认为被拔出
								stateFinishOrder(snNum, 5, "") //1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
							}
						}
						// 强制重新插拔
						if err := RedisSave(snNum+"/connectInfo", "0"); err != nil { // 未连接
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:2,数据库etcd设备未连接信息推送失败"))
						}
						if err = MqttNoticeSend(snNum+"/connectInfo", "0"); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
						}
					}
				})
			}

			if state[0] == '0' && state[1] == '0' && isWorking == "1" {
				time.AfterFunc(60*time.Second, func() {
					if powerUpdateTimeDuration, err := AnalyzeDevDurationGet(snNum + "/powerUpdateTime"); err != nil {
						utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "AnalyzeDevPowerDurationGet,2:etcd服务设备打开时间数据转换失败"))
					} else if time.Duration(powerUpdateTimeDuration)*time.Second > 10*time.Minute { //超过10分钟不更新power
						stateFinishOrder(snNum, 5, "") //1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
						// 强制重新插拔
						if err := RedisSave(snNum+"/connectInfo", "0"); err != nil { // 未连接
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:2,数据库etcd设备未连接信息推送失败"))
						}
						if err = MqttNoticeSend(snNum+"/connectInfo", "0"); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
						}
					}
				})
			}
			if state[0] == '0' && state[1] == '2' && state[2] == '0' && isWorking == "1" {
				time.AfterFunc(2*time.Second, func() {
					stateFinishOrder(snNum, 5, "紧急停止") //1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
					// 强制重新插拔
					if err := RedisSave(snNum+"/connectInfo", "0"); err != nil { // 未连接
						utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:2,数据库etcd设备未连接信息推送失败"))
					}
					if err = MqttNoticeSend(snNum+"/connectInfo", "0"); err != nil {
						utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
					}
				})
			}
			if state[0] == '0' && len(state) >= 7 && state[6] == ';' && isWorking == "0" {
				utils.MyPrint(utils.PRINT_WARN, "******************关闭设备******************")
				if timeout, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "SaveOpenTime,1:etcd服务数据保存失败"))
				} else if timeout {
					utils.MyPrint(utils.PRINT_ERROR, utils.NewError(utils.ErrorTypeStop, "SaveOpenTime,1:etcd服务数据保存失败"))
				} else if operateFlag != 0 {
					utils.MyPrint(utils.PRINT_ERROR, utils.NewError(utils.ErrorTypeStop, "SaveOpenTime,1:etcd服务数据保存失败"))
				}
			}
		}
		// 已经关闭的不应该是打开状态
		if isWorking == "0" && (stateOld[0] == '7' || stateOld[0] == '8' || stateOld[0] == '9') && (state[0] == '7' || state[0] == '8' || state[0] == '9') {
			time.AfterFunc(60*time.Second, func() {
				if qldOutlets, err := models.GetQldOutletsBySnNum(snNum); err != nil {
					utils.MyPrint(utils.PRINT_ERROR, err.Error())
				} else if len(qldOutlets) == 0 {
					utils.MyPrint(utils.PRINT_WARN, "checkState:获取设备失败，snNum="+snNum)
				} else {
					if qldOutlets[0].IsWorking == 0 { //这里数据库和内存中状态不一致，可能是外部修改导致
						// 关闭设备
						timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 1, 10)
						if err != nil {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "OutLetClose:2，控制设备失败2"))
						} else if timeOut {
							utils.MyPrint(utils.PRINT_WARN, "checkState:3,关闭设备超时,snNum=", snNum)
						} else if operateFlag != 0 {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "OutLetClose:2，控制设备失败1"))
						} else {
							if err := RedisSave(snNum+"/connectInfo", "1"); err != nil { // 已连接
								utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,数据库etcd设备已连接信息推送失败"))
							}
							if err = MqttNoticeSend(snNum+"/connectInfo", "1"); err != nil {
								utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "GetQldOutletTypeBySnNum:数据库etcd设备离线信息推送失败"))
							}
						}
					} else {
						if err = RedisSave(snNum+"/isWorking", "1"); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:3,isWorking保存到etcd失败"))
						}
						if err = MqttNoticeSend(snNum+"/isWorking", "1"); err != nil {
							utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkState:isWorking推送失败"))
						}
					}
				}
			})
		}
	}
}
func getChargeInfo(snNum string) (amount, duration int64, electricity float64, amountRecord string, err error) {
	var err1 error
	amountStr, err2 := RedisGet(snNum+"/amount", "0")
	if err2 != nil {
		err = utils.WrapError(err2, "getChargeInfo:电费金额获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	}
	amount, err1 = strconv.ParseInt(amountStr, 10, 64)
	if err1 != nil {
		err = utils.WrapError(err1, "getChargeInfo:电费金额数据转换失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	}
	duration, err1 = AnalyzeDevDurationGet(snNum + "/openTime")
	if err1 != nil {
		err = utils.WrapError(err1, "getChargeInfo:设备打开时间获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	}
	electricityStr, err2 := RedisGet(snNum+"/electricity", "0")
	if err2 != nil {
		err = utils.WrapError(err2, "getChargeInfo:设备电量获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	}
	electricity, err1 = strconv.ParseFloat(electricityStr, 64)
	if err1 != nil {
		err = utils.WrapError(err1, "getChargeInfo:设备电量获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	}
	amountRecord, err1 = RedisGet(snNum+"/amountRecord", "")
	if err1 != nil {
		err = utils.WrapError(err1, "getChargeInfo:电费金额计算记录获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	}
	return
}
func checkErrState(snNum, errState string) (response string, err error) {
	response = "{\"data\":\"ok\"}"
	errStateS := ""

	if errStateS, err = RedisGet(snNum+"/errStateS", ""); err != nil {
		err = utils.WrapError(err, "checkErrState:redis数据isWorking获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	} else if errState == "s" {
		if len(errStateS) == 10 {
			models.SetQldOutleStatus(snNum, 1)
			if err := RedisSave(snNum+"/errStateS", errStateS+"s"); err != nil { // 已连接
				utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkErrState:redis数据errStateS保存失败"))
			}
		} else if len(errStateS) < 10 {
			if err := RedisSave(snNum+"/errStateS", errStateS+"s"); err != nil { // 已连接
				utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkErrState:redis数据errStateS保存失败"))
			}
		}
	} else {
		if len(errStateS) > 0 {
			models.SetQldOutleStatus(snNum, 0)
			if err := RedisSave(snNum+"/errStateS", ""); err != nil { // 已连接
				utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err, "checkErrState:redis数据errStateS保存失败"))
			}
		}
	}

	if isWorkingStr, err2 := RedisGet(snNum+"/isWorking", "0"); err2 != nil {
		err = utils.WrapError(err2, "checkErrState:redis数据isWorking获取失败")
		utils.MyPrint(utils.PRINT_ERROR, err.Error())
	} else if isWorkingStr == "1" {
		response = "{\"data\":\"" + isWorkingStr + "\"}"
		// 0：正常充电
		// 1：电流异常
		// 2：未检测到A电池电压
		// 3：未检测到B电池电压
		// 7：充电电流过小停止
		// 8：充满电自主停止
		// 9：漏电
		// a：短路
		// b：输出错误
		// c：充满电自主停止
		// d: 充电时功率过小停止
		// e：正常结束充电
		// f：电压异常
		// h：电流异常
		// i：电流挡位切换成功
		// v：电压挡位切换成功
		// s：设备未回复电压电流功率
		// y：设备未回复错误状态
		// off-line：设备断开连接
		// ON_LINE: 设备上线
		if len(errStateS) >= 10 {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "状态(s)通信异常停止")
			})
		}
		if errState == "0" || errState == "v" || errState == "e" || errState == "ON_LINE" {

		} else if errState == "1" || errState == "h" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "电流过大")
			})
		} else if errState == "2" || errState == "3" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "未连接电池")
			})
		} else if errState == "c" || errState == "8" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 1, "")
			})
		} else if errState == "9" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电器及电池存在漏电风险")
			})
		} else if errState == "t" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "时间超限")
			})
		} else if errState == "a" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电器及电池存在短路风险")
			})
		} else if errState == "i" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "总电流超限")
			})
		} else if errState == "b" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电器反馈异常")
			})
		} else if errState == "g" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电前输出反馈异常")
			})
		} else if errState == "d" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				utils.MyPrint(utils.PRINT_WARN, "桩号:", snNum, "监测到mqtt报文:", errState, ">>>>>>>>>>用户拔出设备停止")
				stateFinishOrder(snNum, 3, "设备拔出停止")
			})
		} else if errState == "7" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 3, "充电电流过小停止")
			})
		} else if errState == "f" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "电网电压异常")
			})
		} else if errState == "y" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "设备离线")
			})
		} else if errState == "p" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "功率超限")
			})
		} else if errState == "h" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "电流异常")
			})
		} else if errState == "E" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "疑似超标电池")
			})
		} else if errState == "z" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电器及电池存在短路风险")
			})
		} else if errState == "T" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "环境温度过高")
			})
		} else if errState == "dd" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电器功率震荡")
			})
		} else if errState == "uu" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "充电器存在过充风险")
			})
		} else if errState == "Y" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "烟雾报警")
			})
		} else if errState == "h2" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "设备保险疑似损坏")
			})
		} else if errState == "off-line" {
			timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
			if err != nil {
				utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
			}
			utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
			//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
			time.AfterFunc(2*time.Second, func() {
				stateFinishOrder(snNum, 9, "设备离线")
			})
		} else if errState == "x" {
			//modify 20210827
			timetype, _ := RedisGet(snNum+"/timeType", "0")
			if timetype != "2" {
				timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
				if err != nil {
					utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
				}
				utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
				//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
				time.AfterFunc(2*time.Second, func() {
					stateFinishOrder(snNum, 9, "异常停止")
				})
			}

		}
		//  else {
		// 	timeOut, operateFlag, err := OperateDevice(snNum, OperateDeviceCloseIOValue, 0, 2, 15)
		// 	if err != nil {
		// 		utils.MyPrint(utils.PRINT_ERROR, "checkErrState", err.Error(), "结束设备控制失败")
		// 	}
		// 	utils.MyPrint(utils.PRINT_WARN, "timeOut", timeOut, "operateFlag", operateFlag)
		// 	//1充满停止、2金额用完停止、3闲置停止、4汽车未允许充电停止、5拔出停止、6功率超限停止、7电量超限停止、8时间超限停止
		// 	time.AfterFunc(2*time.Second, func() {
		// 		stateFinishOrder(snNum, 9, "状态("+errState+")异常停止")
		// 	})
		// }
	} else {
		response = "{\"data\":\"" + isWorkingStr + "\"}"
	}
	return
}

func CheckState8(snNum string, devType int8) bool {
	if devType == 0 {
		for i := 0; i < 15; i++ {
			if state, err2 := RedisGet(snNum+"/state", "0000000"); err2 != nil {
				utils.MyPrint(utils.PRINT_ERROR, utils.WrapError(err2, "CheckState8:设备state获取失败"))
			} else if state[0] == '8' {
				return true
			}
			time.Sleep(2 * time.Second)
		}
		return false
	}
	return true
}
